Dans le cadre de la validation du Master 1 en Ingénierie mathématique et biostatistique, plus précisément pour le cours de Big Data, nous avons pour tâche la réalisation d'un projet d'analyse de données sous Python. Nous allons utiliser tous les outils vus dans le cours (et d'autres trouvés ailleurs) pour explorer ces données et proposer une analyse des données.
Ce sont des données sur l'ensemble des transactions sur les horodateurs dans la ville de Paris pour l'année 2014. Celles-ci proviennent du site Open Data Paris, répertoire des données ouvertes de la ville de Paris. cette base de données contient deux collections principales :
- transactions : ensemble des paiements
- mobiliers: liste de tous les horodateurs
Description des collections¶
| Intitulé (Horodateurs) | Horodateurs |
| Intitulé (Transactions) | Transactions 2014 |
| Description (Horodateurs) | Cette couche de ponctuels localise géographiquement les horodateurs répartis sur l’ensemble du territoire parisien, gérés par la Mairie de Paris. |
| Description (Transactions) | Fichiers regroupent l’ensemble des transactions de paiement abouties en 2014. |
| Source | Ces fichiers sont extraits du logiciel de Système de Gestion Centralisé des Horodateurs |
| ATTRIBUT | DÉFINITION |
|---|---|
| numhoro | Numéro horodateur |
| adresse | Adresse |
| alim | Type d'alimentation: Pile ou Solaire |
| regime | Type de régime: Mixte ou rotatif |
| tarif | Tarif du stationnement |
| tarifhor | Tarif horaire |
| zoneres | Zones résidentielles |
| durée payée (h) | Durée payée par heure |
| montant carte | Montant payée |
In [1]:
from PIL import Image
In [2]:
myImage = Image.open("horo_cb.png")
myImage
Out[2]:
Importation de library¶
In [3]:
import pymongo
import pandas as pd
import numpy as np
import pprint
import matplotlib.pyplot as plt
import seaborn as sns
import folium
import json
from folium.plugins import MarkerCluster
con = pymongo.MongoClient("mongodb://193.51.82.104:2343/")
%matplotlib inline
horo = con.horodateurs
horo.list_collection_names()
Out[3]:
In [4]:
def affiche(res):
pprint.pprint(list(res))
Affichage des premiers documents dans les deux collections¶
- Mobiliers
- Transactions
In [5]:
pprint.pprint(horo.mobiliers.find_one())
In [6]:
pprint.pprint(horo.transactions.find_one())
Nombre de transactions effectuées¶
In [7]:
horo.transactions.estimated_document_count()
Out[7]:
In [8]:
horo.transactions_small.count_documents({})
Out[8]:
Nombre d'horodateurs¶
In [9]:
horo.mobiliers.count_documents({})
Out[9]:
Moyen de paiement utilisé¶
In [10]:
horo.transactions.distinct("moyen de paiement")
Out[10]:
Nombre de transactions pour chaque moyen de paiement¶
In [11]:
res=horo.transactions.aggregate([
{"$group":{"_id":"$moyen de paiement", "nombre":{"$sum":1}}}
])
affiche(res)
Différent type d'usager¶
In [12]:
horo.transactions.distinct("usager")
Out[12]:
Nombre de transactions par type d'usager¶
In [13]:
res=horo.transactions.aggregate([
{"$group":{"_id":"$usager", "nombre":{"$sum":1}}}
])
affiche(res)
Durée maximale de stationnement¶
In [14]:
res=horo.transactions.aggregate([
{"$group":{"_id":"durée maximale payée (h)", "temps":{"$max":"$durée payée (h)"} }}
])
affiche(res)
Montant total des transactions¶
In [15]:
res=horo.transactions.aggregate([
{"$group":{"_id":"Total","nb":{"$sum":"$montant carte"}}}
])
affiche(res)
Montant total par type d'usager¶
In [16]:
res=horo.transactions.aggregate([
{"$group":{"_id":"$usager","nb":{"$sum":"$montant carte"}}}
])
affiche(res)
Montant total par moyen de paiement¶
In [17]:
res=horo.transactions.aggregate([
{"$group":{"_id":"$moyen de paiement","nb":{"$sum":"$montant carte"}}}
])
affiche(res)
Différents types d'alimentations¶
In [18]:
horo.mobiliers.distinct("fields.alim")
Out[18]:
Nombre d'horodateurs par type d'alimentation¶
In [19]:
res=horo.mobiliers.aggregate([
{"$group":{"_id":"$fields.alim","nb":{"$sum":1}}}
])
affiche(res)
Différents arrondissements représentés¶
In [20]:
sorted(horo.mobiliers.distinct("fields.arrondt"))
Out[20]:
Nombre de mobiliers par arrondissement¶
In [21]:
res = horo.mobiliers.aggregate([
{ "$group" : { "_id" : "$fields.arrondt", "nb" : { "$sum" : 1}}},
{ "$sort" : { "_id": 1}}
])
data_nb_imob=pd.DataFrame(list(res))
data_nb_imob.columns = ["Arrondissement", "Effectif"]
data_nb_imob.head()
Out[21]:
Différent type de modèle d'horodateur¶
In [22]:
res=horo.mobiliers.distinct("fields.modele")
affiche(res)
Nombre d'horodateurs par modèle¶
In [23]:
res=horo.mobiliers.aggregate([
{"$group":{"_id":"$fields.modele","nb":{"$sum":1}}}
])
affiche(res)
Rem: Il y a 1 mobilier pour lequel on ne connait pas le modèle¶
Différent type de régime¶
In [24]:
res=horo.mobiliers.distinct("fields.regime")
affiche(res)
Nombre d'horodateurs par régime¶
In [25]:
res=horo.mobiliers.aggregate([
{"$group":{"_id":"$fields.regime","nb":{"$sum":1}}}
])
affiche(res)
Tarif horaire¶
In [26]:
res=horo.mobiliers.distinct("fields.tarifhor")
affiche(res)
Nombre de transactions par horodateur¶
In [27]:
res=horo.transactions.aggregate([
{"$group":{"_id":"$horodateur", "nombre":{"$sum":1}}}
])
data_horo=pd.DataFrame(list(res))
data_horo.head()
Out[27]:
Montant total effectué par horodateur¶
In [28]:
res=horo.transactions.aggregate([
{"$group":{"_id":"$horodateur","somme":{"$sum":"$montant carte"}}}
])
data_montant=pd.DataFrame(list(res))
data_montant.head()
Out[28]:
In [29]:
data_montant["nbr_transactions"]=data_horo.nombre
data_montant.head()
Out[29]:
Répartition des mobiliers par arrondissement et par tarif horaire¶
In [30]:
res=horo.mobiliers.aggregate([
{"$project": {
"_id": 0,
"num_horo" : "$fields.numhoro",
"arrond" : "$fields.arrondt",
"tarif":"$fields.tarifhor"
}},
{ "$sort": {
"arrond": 1
}}
])
A=list(res)
data1=pd.DataFrame({"num_horo":[i["num_horo"] for i in A],"arrondt":[i["arrond"] for i in A],\
"tarif":[i['tarif'] for i in A]})
data1.head()
Out[30]:
Nombre de données manquantes dans la collection transactions¶
In [31]:
num_manquant=list(set(data_horo._id)-set(data1.num_horo))
len(num_manquant)
Out[31]:
!!! On constate qu'il y a au total 117 horodateurs dans la collection transactions qui ne sont pas dans la collection mobiliers. On va donc considérer pour la suite que ce sont des données manquantes¶
Nombre de mobiliers par arrondissement à l'aide des barres¶
In [32]:
sns.countplot(x = "arrondt" ,data = data1,saturation=1)
Out[32]:
Tarif horaire de stationnement par arrondissement¶
In [33]:
sns.catplot(x = "arrondt", y = "tarif", data = data1, kind = "point",hue="arrondt", join = False)
Out[33]:
Pour les arrondissements 1 jusqu'à 11 le tarif horaire est de 4 euros et pour les arrondissements 12 à 20, 2.4 euros¶
Montant total des transactions sur les données manquantes¶
In [34]:
vect=0
for i in num_manquant:
vect+=list(data_montant.loc[data_montant._id==i].somme)[0]
vect
Out[34]:
Montant total des transactions sur les données retenues¶
In [35]:
np.sum(data_montant.somme)-vect
Out[35]:
Nombre de transactions par arrondissement¶
In [36]:
trans={}
for i in range(1,21):
df1=data1[data1["arrondt"]==i]
liste1=[i for i in df1.num_horo]
vect=0
for j in range(len(liste1)):
df2=data_horo[data_horo["_id"]==liste1[j]]
vect+=np.sum(df2["nombre"])
trans[i]=vect
pd.Series(trans)
Out[36]:
Montant total par arrondissement¶
In [37]:
Somme_trans={}
for i in range(1,21):
df1=data1[data1["arrondt"]==i]
liste1=[i for i in df1.num_horo]
vect=0
for j in range(len(liste1)):
df2=data_montant[data_montant["_id"]==liste1[j]]
vect+=np.sum(df2["somme"])
Somme_trans[i]=vect
pd.Series(Somme_trans)
Out[37]:
In [38]:
#Vérification: Montant total
np.sum(list(Somme_trans.values()))
Out[38]:
In [39]:
x0=range(1,21)
z0=list(Somme_trans.values())
z1=list(trans.values())
z2=data_nb_imob.Effectif
plt.plot(x0, z0, "o-", label="Somme_trans -",color="blue")
plt.plot(x0, z1, "o:", label="Nbr_trans :", color="purple")
plt.title("Nombre et Montant des transactions VS Arrondissement")
plt.xlabel("Arrondissement",fontsize=14)
plt.legend()
plt.show()
In [40]:
plt.plot(x0, z2, "o--", label="Nb_horodateur--",color="red")
plt.xlabel("Arrondissement",fontsize=14)
plt.title("Nombre de mobiliers VS Arrondissement")
plt.legend()
plt.show()
Rem: On constate que les trois variables ont tendance à évoluer de la même manière.¶
In [41]:
sns.jointplot(x = z0, y = z1, kind="reg", color="red")
Out[41]:
In [42]:
sns.jointplot(x = z1, y = z2, kind="reg", color="#feb24c")
Out[42]:
In [43]:
don=pd.DataFrame({"Nombre_horo":z2,"Somme_trans":z0,"Nbr_trans":z1})
don.corr()
Out[43]:
In [44]:
sns.heatmap(don.corr())
Out[44]:
Au vu des graphiques précédents et au vu de la carte de chaleur on déduit qu'il y a une forte correlation entre les trois variables¶
Tarif horaire moyen par arrondissement¶
In [45]:
tarif_moyen_arr=pd.Series(data1.groupby('arrondt')["tarif"].mean().round(2))
tarif_moyen_arr
Out[45]:
Répartition des horodateurs par type d'alimentation et par arrondissement¶
In [46]:
res=horo.mobiliers.aggregate([
{"$group":{"_id":{"Alimentation":"$fields.alim","Arrondissement":"$fields.arrondt"},
"nb":{"$sum":1}}},
{"$sort":{"fields.arrondt":1}}
])
data_alim=pd.DataFrame(list(res))
# On supprime les lignes ayant les valeurs manquantes (type d'alimentation)
data_alim1=data_alim.drop([4,5,8,24,28,32])
data_alim1.head()
Out[46]:
Nombre d'horodateurs par arrondissement pour le type d'alimentation solaire¶
In [47]:
Aliment_=[i["Alimentation"] for i in data_alim1['_id']]
arrondt_=[i["Arrondissement"] for i in data_alim1['_id']]
data_alim2=pd.DataFrame({"Arrondissement":arrondt_,"Alimentation":Aliment_})
data_alim2["nb"]=data_alim1.nb
data_alim_sol=data_alim2.query("Alimentation=='SOLAIRE'").sort_values(by="Arrondissement")
data_alim_sol.iloc[[0,10,17,18],2]=0
data_alim_pile=data_alim2.query("Alimentation=='PILE'").sort_values(by="Arrondissement")
data_alim_pile.iloc[[2,9],2]=0 # On remplace les valeurs manquantes par zéro
data_al=pd.DataFrame({"Arrondissement":list(set(range(1,21))-set(data_alim_pile.Arrondissement)),
"Alimentation":np.repeat("PILE",20-len(data_alim_pile)),
"nb":np.repeat(0,20-len(data_alim_pile))})
data_alim_PILE= data_alim_pile.append(data_al, ignore_index=True).sort_values(by="Arrondissement")
data_alim2.head()
Out[47]:
In [48]:
sns.catplot(x = "Alimentation", y = "nb", data = data_alim2, kind = "box")
Out[48]:
Rem: en moyenne il y a plus de mobiliers à alimentation pile que de mobiliers à alimentation solaire¶
Nombre d'horodateurs par arrondissement pour le type d'alimentation Pile¶
In [49]:
data_alim_PILE.head()
Out[49]:
In [50]:
y10=data_alim_PILE.nb
y20=data_alim_sol.nb
plt.title("Nombre d'horodateurs par arrondissement et par type d'alimentation")
plt.plot(x0, y10, "r--", label="PILE --")
plt.plot(x0, y20, "b:o", label="SOLAIRE o")
plt.xlabel("Arrondissement",fontsize=14)
plt.legend()
plt.show()
Répartition des horodateurs par modèle et par arrondissement¶
In [51]:
res=horo.mobiliers.aggregate([
{"$group":{"_id":{"Modele":"$fields.modele","Arrondissement":"$fields.arrondt"},
"nb":{"$sum":1}}}
])
data_modele=pd.DataFrame(list(res))
data_modele.head()
Out[51]:
Nombre d'horodateurs modèle SMB2 par arrondissement¶
In [52]:
## On supprime la ligne 3 [valeur manquante (modèle)]
data_modele1=data_modele.drop([3])
Modele_=[i["Modele"] for i in data_modele1['_id']]
arrondt_m=[i["Arrondissement"] for i in data_modele1['_id']]
data_modele2=pd.DataFrame({"Arrondissement":arrondt_m,"modele":Modele_})
data_modele2["nb"]=data_modele1.nb
data_modele2.head()
Out[52]:
In [53]:
sns.catplot(x = "modele", y = "nb", data = data_modele2, kind = "box")
Out[53]:
En moyenne on a retrouve plus de mobiliers de modèle SAB3, ensuite SMB2 et enfin MUI.¶
In [54]:
data_modele_smb=data_modele2.query("modele=='SMB2'")
dat_m2=pd.DataFrame([[1, "SMB2", 0],[2, "SMB2", 0],
[3, "SMB2", 0],[4, "SMB2", 0],
[11, "SMB2", 0],[13, "SMB2", 0],[8, "SMB2", 0]],columns=data_modele2.columns)
data_modele_smb2=data_modele_smb.append(dat_m2, ignore_index=True).sort_values(by = 'Arrondissement',
ascending = True)
data_modele_smb2.head()
Out[54]:
Nombre d'horodateurs modèle MUI par arrondissement¶
In [55]:
data_modele_mui=data_modele2.query("modele=='MUI'")
data_modele_mui
dat_mui=pd.DataFrame({"Arrondissement":[i for i in range(21) if i not in [0,1,8,15]],
"modele":np.repeat("MUI",17),"nb":np.repeat(0,17)})
data_modele_MUI=data_modele_mui.append(dat_mui, ignore_index=True).sort_values(by="Arrondissement")
data_modele_MUI.head()
Out[55]:
Nombre d'horodateurs de modèle SAB3 par arrondissement¶
In [56]:
data_modele_sab3=data_modele2.query("modele=='SAB3'")
data_modele_SAB3=data_modele_sab3.sort_values(by="Arrondissement")
data_modele_SAB3.iloc[[6],2]=0
data_modele_SAB3.head()
Out[56]:
In [57]:
y0=data_modele_smb2.nb
y01=data_modele_MUI.nb
y02=data_modele_SAB3.nb
plt.title("Nombre d'horodateurs par arrondissement et par modèle")
plt.plot(x0, y0, "o-", label="SMB2 -")
plt.plot(x0, y01, "o:", label="MUI :")
plt.plot(x0, y02, "o--", label="SAB3--")
plt.xlabel("Arrondissement",fontsize=14)
plt.legend()
plt.show()
Nombre d'horodateurs par type de régime et par arrondissement¶
In [58]:
res=horo.mobiliers.aggregate([
{"$group":{"_id":{"Regime":"$fields.regime","Arrondissement":"$fields.arrondt"},
"nb":{"$sum":1}}}
])
data_regime=pd.DataFrame(list(res))
data_regime.head()
Out[58]:
Nombre d'horodateurs de régime ROT par arrondissement¶
In [59]:
regime_=[i["Regime"] for i in data_regime['_id']];arrondt_r=[i["Arrondissement"] for i in data_regime['_id']]
data_regime1=data_regime.drop(["_id"],axis=1)
data_regime1["Arrondissement"]=arrondt_r; data_regime1["Regime"]=regime_
data_ROT=data_regime1.sort_values(by="Arrondissement",ascending=True).query("Regime=='ROT'")
data_MIX=data_regime1.sort_values(by="Arrondissement",ascending=True).query("Regime=='MIX'")
data_ROT.head()
Out[59]:
Nombre d'horodateurs de régime MIX par arrondissement¶
In [60]:
data_MIX.head()
Out[60]:
In [61]:
y1=data_MIX.nb
y2=data_ROT.nb
plt.title("Nombre d'horodateurs par type de régime VS arrondissement")
plt.plot(x0, y1, "o-", label="MIX -")
plt.plot(x0, y2, "o--", label="ROT--")
plt.xlabel("Arrondissement",fontsize=14)
plt.ylabel("Nombre d'horodateurs",fontsize=14)
plt.legend()
plt.show()
Montant des transactions par moyen de paiement¶
In [62]:
res=horo.transactions.aggregate([
{"$group":{"_id":{"montant_carte":"$montant carte",
"moyen":"$moyen de paiement"},"nb":{"$sum":1}}},
{
"$sort":{"nb":1}
}
])
df0=pd.DataFrame(list(res))
df0.head()
Out[62]:
In [63]:
df0["montant_carte"]=[i["montant_carte"] for i in df0._id]
df0["moyen_paiement"]=[i["moyen"] for i in df0._id]
df0["somme"]=df0.nb*df0.montant_carte
df0.head()
Out[63]:
In [64]:
sns.catplot(x = "moyen_paiement", y = "somme", data = df0, kind = "violin")
Out[64]:
In [65]:
sns.pointplot(x ="moyen_paiement", y = "somme", data = df0, kind = "point",join=False)
Out[65]:
In [66]:
sns.lmplot("montant_carte", "nb", hue = "moyen_paiement", col = "moyen_paiement", data = df0)
Out[66]:
In [67]:
df0.groupby("moyen_paiement")["somme"].mean()
Out[67]:
Rem: En moyenne on constate une légère différence entre le montant total effectué par Paris carte et par CB¶
In [68]:
sns.relplot(x="montant_carte", y="nb", hue="moyen_paiement", kind="line", data=df0)
Out[68]:
Nombre de transactions par montant et par type d'usager¶
In [69]:
res=horo.transactions.aggregate([
{"$group":{"_id":{"montant_carte":"$montant carte",
"usager":"$usager"},"nb":{"$sum":1}}},
{
"$sort":{"nb":1}
}
])
df1=pd.DataFrame(list(res))
df1.head()
Out[69]:
In [70]:
df1["montant_carte"]=[i["montant_carte"] for i in df1._id]
df1["usager"]=[i["usager"] for i in df1._id]
df1["total"]=df1.nb*df1.montant_carte
df1.head()
Out[70]:
Nombre de transactions par horodateur et par type d'usager¶
In [71]:
res=horo.transactions.aggregate([
{"$group":{"_id":{"num":"$horodateur",
"usager":"$usager"},"nb":{"$sum":1}}},
{
"$sort":{"nb":1}
}
])
df2=pd.DataFrame(list(res))
df2.head()
Out[71]:
Nombre de transactions pour le type d'usager Résident¶
In [72]:
df2["_id1"]=[i["num"] for i in df2._id]
df2["usager"]=[i["usager"] for i in df2._id]
df2_usager_rot=df2.drop(["_id"],axis=1).query("usager=='Rotatif'")
df2_usager_res=df2.drop(["_id"],axis=1).query("usager=='Résident'")
df2_usager_res.head()
Out[72]:
Nombre de transactions par arrondissement pour le type d'usager Résident¶
In [73]:
usager_res={}
for i in range(1,21):
df1=data1[data1["arrondt"]==i]
liste1=[i for i in df1.num_horo]
vect=0
for j in range(len(liste1)):
df2=df2_usager_res[df2_usager_res["_id1"]==liste1[j]]
vect+=np.sum(df2["nb"])
usager_res[i]=vect
pd.Series(usager_res)
Out[73]:
Nombre de transactions pour le type d'usager Rotatif¶
In [74]:
df2_usager_rot.head()
Out[74]:
Nombre de transactions par arrondissement pour le type d'usager Rotatif¶
In [75]:
usager_r={}
for i in range(1,21):
df1=data1[data1["arrondt"]==i]
liste1=[i for i in df1.num_horo]
vect=0
for j in range(len(liste1)):
df2=df2_usager_rot[df2_usager_rot["_id1"]==liste1[j]]
vect+=np.sum(df2["nb"])
usager_r[i]=vect
pd.Series(usager_r)
Out[75]:
In [76]:
t0=list(usager_res.values())
t1=list(usager_r.values())
plt.plot(x0, t0, "o-", label="usager_res -",color="#91FF33")
plt.plot(x0, t1, "o:", label="usager_rot :", color="#FF33FE")
plt.title("Nombre de transactions par type d'usager VS Arrondissement")
plt.xlabel("Arrondissement",fontsize=14)
plt.legend()
plt.show()
Nombre de transactions par moyen de paiement et par horodateur¶
In [77]:
res=horo.transactions.aggregate([
{"$group":{"_id":{"num":"$horodateur",
"moyen":"$moyen de paiement"},"nb":{"$sum":1}}},
{
"$sort":{"nb":1}
}
])
df3=pd.DataFrame(list(res))
df3.head()
Out[77]:
In [78]:
df3["_id1"]=[i["num"] for i in df3._id]
df3["moyen"]=[i["moyen"] for i in df3._id]
df3_PC=df3.query("moyen=='Paris Carte'")
df3_PC.head()
Out[78]:
Nombre transactions par arrondissement pour le moyen de paiement Paris Carte¶
In [79]:
moyen_PC={}
for i in range(1,21):
df1=data1[data1["arrondt"]==i]
liste1=[i for i in df1.num_horo]
vect=0
for j in range(len(liste1)):
df2=df3_PC[df3_PC["_id1"]==liste1[j]]
vect+=np.sum(df2["nb"])
moyen_PC[i]=vect
pd.Series(moyen_PC)
Out[79]:
In [80]:
df3_CB=df3.query("moyen=='CB'")
df3_CB.head()
Out[80]:
Nombre transactions par arrondissement pour le moyen de paiement CB¶
In [81]:
moyen_CB={}
for i in range(1,21):
df1=data1[data1["arrondt"]==i]
liste1=[i for i in df1.num_horo]
vect=0
for j in range(len(liste1)):
df2=df3_CB[df3_CB["_id1"]==liste1[j]]
vect+=np.sum(df2["nb"])
moyen_CB[i]=vect
pd.Series(moyen_CB)
Out[81]:
In [82]:
h0=list(moyen_PC.values())
h1=list(moyen_CB.values())
plt.plot(x0, h0, "o-", label="moyen_PC -",color="blue")
plt.plot(x0, h1, "o:", label="moyen_CB :", color="purple")
plt.title("Nombre de transactions par moyen de paiement VS arrondissement")
plt.xlabel("Arrondissement",fontsize=14)
plt.grid(True)
plt.legend()
plt.show()
In [83]:
print(df3.groupby("moyen")["nb"].mean())
ast=(abs(df3_CB.nb.mean()-df3_PC.nb.mean())).round()
'Soit une différence en moyenne de : {ast} ' . format ( ast=str(ast))
Out[83]:
Rem: On constate une légère différence entre le nombre de transactions effectués par Paris Carte et CB¶
Nombre de transactions par montant et par durée payée¶
In [84]:
res=horo.transactions.aggregate([
{"$group":{"_id":{"durée_payée":"$durée payée (h)","montant_carte":"$montant carte"},"nb":{"$sum":1}}}
])
df4=pd.DataFrame(list(res))
df4.head()
Out[84]:
In [85]:
df4["durée_payée"]=[i['durée_payée'] for i in df4._id]
df4["montant_carte"]=[i['montant_carte'] for i in df4._id]
df4.head()
Out[85]:
Estimation de la densité en 2d¶
In [86]:
sns.jointplot(x = "durée_payée", y = "montant_carte", data = df4, kind = "kde")
Out[86]:
In [87]:
cmap = sns.cubehelix_palette(dark=.3, light=.8, as_cmap=True)
ax = sns.scatterplot(x="montant_carte", y="durée_payée",
hue="nb", size="nb",
sizes=(20, 200), hue_norm=(0, 7),
data=df4)
In [88]:
t = pd.crosstab(pd.cut(df4.montant_carte, bins = 6),
df4.nb,
values = df4.durée_payée, aggfunc = np.mean)
sns.heatmap(t)
Out[88]:
Nous allons regrouper les variables précédentes pour créer un dataframe, afin de pouvoir réaliser une analyse des composantes principales.¶
| VARIABLE | DESCRIPTION |
|---|---|
| Arrondt | Arrondissement |
| Nbr_mob | Nombre de mobiliers par arrondissement |
| Nbr_trans | Nombre de transactions par arrondissement |
| Sum_trans | Montant total des transactions par arrondissement |
| Tarif_moy | Tarif moyen de stationnement par arrondissement |
| Nbr_reg_rot | Nombre d'horodateurs de régime ROT par arrondissement |
| Nbr_reg_mix | Nombre d'horodateurs de régime MIX par arrondissement |
| Nbr_mod_SMB2 | Nombre d'horodateurs de modèle SMB2 par arrondissement |
| Nbr_mod_MUI | Nombre d'horodateurs de modèle MUI par arrondissement |
| Nbr_mod_SAB3 | Nombre d'horodateurs de modèle SAB3 par arrondissement |
| Nbr_alim_pile | Nombre d'horodateurs à pile par arrondissement |
| Nbr_alim_sol | Nombre d'horodateurs à alimentation solaire par arrondissement |
| moyen_PC | Montant payée par moyen: Paris Carte par arrondissement |
| moyen_CB | Montant payée payée par moyen: CB par arrondissement |
| usager_res | Nombre de transactions par arrondissement pour le type d'usager Résident |
| usager_rot | Nombre de transactions par arrondissement pour le type d'usager Rotatif |
In [89]:
New_data=pd.DataFrame({"Arrondt":range(1,21),"Nbr_mob":list(data_nb_imob.Effectif),"Nbr_trans":list(trans.values()),
"Sum_trans":list(Somme_trans.values()),"Tarif_moy":list(tarif_moyen_arr),"Nbr_reg_rot":list(data_ROT.nb),
"Nbr_reg_mix":list(data_MIX.nb),"Nbr_mod_SMB2":list(data_modele_smb2.nb),
"Nbr_mod_MUI":list(data_modele_MUI.nb),"Nbr_mod_SAB3":list(data_modele_SAB3.nb),
"Nbr_alim_pile":list(data_alim_PILE.nb),"Nbr_alim_sol":list(data_alim_sol.nb),
"moyen_PC":h0,"moyen_CB":h1,"usager_res":t0,"usager_rot":t1}, index=range(20))
X=New_data.iloc[:,1:]
New_data
Out[89]:
Corrélation entre les variables¶
In [90]:
sns.set(style="white")
corr = X.corr()
mask = np.triu(np.ones_like(corr, dtype=np.bool))
f, ax = plt.subplots(figsize=(11, 9))
cmap = sns.diverging_palette(220, 10, as_cmap=True)
sns.heatmap(corr, mask=mask, cmap=cmap, center=0,
square=True, linewidths=.5, cbar_kws={"shrink": .5})
Out[90]:
Faisons une analyse de composantes principales¶
In [91]:
from sklearn.decomposition import PCA
from sklearn.preprocessing import scale
In [92]:
pca = PCA()
pca.fit(scale(X))
Out[92]:
In [93]:
print(pca.explained_variance_)
print(pca.explained_variance_ratio_)
In [94]:
tab = pd.DataFrame(
{
"Dimension" : ["Dim" + str(x + 1) for x in range(15)],
"Valeur propre" : pca.explained_variance_,
"% variance expliquée" : np.round(pca.explained_variance_ratio_ * 100),
"% cum. var. expliquée" : np.round(np.cumsum(pca.explained_variance_ratio_) * 100)
},
columns = ["Dimension", "Valeur propre", "% variance expliquée", "% cum. var. expliquée"]
)
tab.head()
Out[94]:
La première composante accapare 61% de la variance, il y a donc un fort effet de taille dans les données.¶
In [95]:
n_components = 15
ind = np.arange(0, n_components)
(fig, ax) = plt.subplots(figsize=(8, 6))
sns.pointplot(x=ind, y=pca.explained_variance_ratio_,color="red")
ax.set_title('Scree plot')
ax.set_xticks(ind)
ax.set_xticklabels(ind)
ax.set_xlabel('Numéro_composante')
ax.set_ylabel('Explained Variance')
plt.show()
In [96]:
reduced=pca.fit_transform(X)
for i in range(0, n_components):
X['PC' + str(i + 1)] = reduced[:, i]
display(X.head())
In [97]:
(fig, ax) = plt.subplots(figsize=(10, 10))
for i in range(0, 15):
ax.arrow(0,
0,
pca.components_[0, i],
pca.components_[1, i],
head_width=0.1,
head_length=0.1)
plt.text(pca.components_[0, i] + 0.05,
pca.components_[1, i] + 0.05,
X.columns.values[i],bbox=dict(facecolor='green', alpha=0.5))
an = np.linspace(0, 2 * np.pi, 100)
plt.plot(np.cos(an), np.sin(an))
plt.axis('equal')
ax.set_title('Variable factor map')
plt.show()
In [98]:
(fig, ax) = plt.subplots(figsize=(6, 6))
for i in range(0, 3):
ax.arrow(0,
0,
pca.components_[0, i],
pca.components_[1, i],
head_width=0.1,
head_length=0.1)
plt.text(pca.components_[0, i] + 0.05,
pca.components_[1, i] + 0.05,
X.columns.values[i],bbox=dict(facecolor='red', alpha=0.5))
an = np.linspace(0, 2 * np.pi, 100)
plt.plot(np.cos(an), np.sin(an))
plt.axis('equal')
ax.set_title('Variable factor map')
plt.show()
On transforme la collection mobiliers en dataframe.¶
In [99]:
res=horo.mobiliers.find()
dm=pd.DataFrame(list(res))
dm.head()
Out[99]:
On choisit les 7 arrondissements les moins représentés en terme de nombre de mobiliers¶
In [100]:
data_nb_imob.sort_values(by="Effectif").head(7)["Effectif"].sum()
moins=list(data_nb_imob.sort_values(by="Effectif").head(7).Arrondissement)
sorted(moins)
Out[100]:
On récupère l'arrondissement, l'adresse, et le tarif horaire de stationnement pour les mobiliers dans ces arrondissements¶
In [101]:
res=horo.mobiliers.find({"fields.arrondt":{"$in": moins}},
{"_id":0,"fields.geo_point_2d":1,"fields.arrondt":1,"fields.tarifhor":1,
"fields.adresse":1})
d1_7=pd.DataFrame(list(res))
d1_7.head()
Out[101]:
Représentation¶
In [102]:
centre = [48.86, 2.35]
carte = folium.Map(location = centre, zoom_start = 12, tiles ='Cartodb Positron')
groupes = MarkerCluster().add_to(carte)
for i in range(len(d1_7)):
pr=d1_7.fields[i]
centre1=pr["geo_point_2d"]
adr=pr["adresse"]
tr=pr["tarifhor"]
pop=pr["arrondt"]
folium.Marker(location=centre1,tooltip=str(adr)+", tarif: "+str(tr)+"€",\
popup=str(pop),icon=folium.Icon(icon="car",color='purple',\
icon_color="blue",prefix="fa")).add_to(groupes)
carte
Out[102]:
Les trois arrondissements les plus représentés¶
In [103]:
plus=list(data_nb_imob.sort_values(by="Effectif").tail(3).Arrondissement)
plus
Out[103]:
In [104]:
res=horo.mobiliers.find({"fields.arrondt":{"$in": plus}},
{"_id":0,"fields.geo_point_2d":1,"fields.arrondt":1,"fields.tarifhor":1,
"fields.adresse":1})
d1_2=pd.DataFrame(list(res))
d1_2.shape
Out[104]:
1000 horodateurs parmi les 2467¶
In [105]:
centre = [48.86, 2.35]
carte = folium.Map(location = centre, zoom_start = 12, tiles ='Cartodb Positron')
groupes = MarkerCluster().add_to(carte)
for i in range(1000):
pr=d1_2.fields[i]
centre1=pr["geo_point_2d"]
adr=pr["adresse"]
tr=pr["tarifhor"]
pop=pr["arrondt"]
folium.Marker(location=centre1,tooltip=str(adr)+",tarif: "+str(tr)+"€",\
popup=str(pop),icon=folium.Icon(icon="car",color='purple',\
icon_color="black",prefix="fa")).add_to(groupes)
carte
Out[105]:
In [106]:
import json
geo = json.load(open("paris-arrondissements.geojson"))
Nombre de mobiliers par quartier¶
In [107]:
centre = [48.86, 2.35]
carte = folium.Map(location = centre, zoom_start = 12,tiles ='Cartodb Positron')
folium.Choropleth(geo_data = geo, key_on = "feature.properties.c_ar",
data = New_data, columns = ["Arrondt", "Nbr_mob"],
fill_color= "Pastel1",
legend_name = "Nombre de mobiliers par arrondissement").add_to(carte)
carte
Out[107]:
Nombre de transactions par quartier¶
In [108]:
carte = folium.Map(location = centre, zoom_start = 12,tiles ='Cartodb Positron')
folium.Choropleth(geo_data = geo, key_on = "feature.properties.c_ar",
data = New_data, columns = ["Arrondt", "Nbr_trans"],
fill_color= "Pastel1",
legend_name = "Nombre de transactions par quartier").add_to(carte)
carte
Out[108]:
Montant total des transactions par arrondissement¶
In [109]:
carte = folium.Map(location = centre, zoom_start = 12,tiles ='Cartodb Positron')
folium.Choropleth(geo_data = geo, key_on = "feature.properties.c_ar",
data = New_data, columns = ["Arrondt", "Sum_trans"],
fill_color= "Pastel1",
legend_name = "Montant total des transactions par arrondissement").add_to(carte)
carte
Out[109]: